.TH std::get_deleter 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::get_deleter \- std::get_deleter

.SH Synopsis
   Defined in header <memory>
   template< class Deleter, class T >                             \fI(since C++11)\fP
   Deleter* get_deleter( const std::shared_ptr<T>& p ) noexcept;

   Access to the p's deleter. If the shared pointer p owns a deleter of type
   cv-unqualified Deleter (e.g. if it was created with one of the constructors that
   take a deleter as a parameter), then returns a pointer to the deleter. Otherwise,
   returns a null pointer.

.SH Parameters

   p - a shared pointer whose deleter needs to be accessed

.SH Return value

   A pointer to the owned deleter or nullptr. The returned pointer is valid at least as
   long as there remains at least one shared_ptr instance that owns it.

.SH Notes

   The returned pointer may outlive the last shared_ptr if, for example, std::weak_ptrs
   remain and the implementation doesn't destroy the deleter until the entire control
   block is destroyed.

.SH Example

   Demonstrates that std::shared_ptr deleter is independent of the shared_ptr's type.


// Run this code

 #include <iostream>
 #include <memory>

 struct Foo { int i; };
 void foo_deleter(Foo* p)
 {
     std::cout << "foo_deleter called!\\n";
     delete p;
 }

 int main()
 {
     std::shared_ptr<int> aptr;

     {
         // create a shared_ptr that owns a Foo and a deleter
         auto foo_p = new Foo;
         std::shared_ptr<Foo> r(foo_p, foo_deleter);
         aptr = std::shared_ptr<int>(r, &r->i); // aliasing ctor
         // aptr is now pointing to an int, but managing the whole Foo
     } // r gets destroyed (deleter not called)

     // obtain pointer to the deleter:
     if (auto del_p = std::get_deleter<void(*)(Foo*)>(aptr))
     {
         std::cout << "shared_ptr<int> owns a deleter\\n";
         if (*del_p == foo_deleter)
             std::cout << "...and it equals &foo_deleter\\n";
     }
     else
         std::cout << "The deleter of shared_ptr<int> is null!\\n";
 } // deleter called here

.SH Output:

 shared_ptr<int> owns a deleter
 ...and it equals &foo_deleter
 foo_deleter called!

.SH See also

   constructor   std::shared_ptr constructors
                 \fI(public member function)\fP
   get_deleter   returns the deleter that is used for destruction of the managed object
                 \fI(public member function of std::unique_ptr<T,Deleter>)\fP
